import re
from py2neo import Graph

# 步骤A: 连接到图数据库（与导入脚本配置一致）
try:
    graph = Graph("bolt://47.120.77.67:7687", auth=("neo4j", "053116wj"))
    print("成功连接到图数据库！")
except Exception as e:
    print(f"连接数据库失败：{e}")
    graph = None


# --- 核心函数：只负责执行查询并返回原始数据 ---
def execute_query_and_get_data(query: str) -> list:
    """
    执行 Cypher 查询并返回原始数据列表。
    与导入脚本对齐：所有节点核心属性为「name」，关系类型严格匹配。
    """
    if not graph:
        return []
    try:
        return graph.run(query).data()
    except Exception as e:
        print(f"查询出错: {e}")
        return []


# ----------------专用的格式化函数（与导入数据结构对齐） ---------------------------
def format_general_answer(data: list, entity_name: str, relationship_type: str) -> str:
    """通用查询的回答函数（多结果用“、”连接）"""
    if not data:
        return f"回答：抱歉，没有找到关于“{entity_name}”的{relationship_type}信息。请继续补充相关知识！"

    # 所有节点的核心属性均为「name」（与导入脚本一致）
    result_list = [f"《{item['target']}》" for item in data if 'target' in item and item['target']]

    max_show = 20
    if len(result_list) > max_show:
        formatted_result = "\n".join([f"{idx+1}. {content}" for idx, content in enumerate(result_list[:max_show])])
        return f"回答：“{entity_name}”类型甜味剂{relationship_type}共{len(result_list)}条，显示前{max_show}条：\n{formatted_result}"
    else:
        formatted_result = "\n".join([f"{idx+1}. {content}" for idx, content in enumerate(result_list)])
        return f"回答：“{entity_name}”类型甜味剂{relationship_type}如下：\n{formatted_result}"

def format_experimental_method_answer(data: list, entity_name: str,relationship_type: str) -> str:
    """致甜成分实验方法的查询函数"""
    if not data:
        return f"回答：抱歉，没有找到“{entity_name}”的实验方法信息。请继续补充相关知识！"

    def normalize_text(text):
        # 1. 中文逗号→英文逗号 2. 中文句号→英文句号 3. 去除前后多余空格
        return text.replace('，', ',').replace('。', '.').strip()
    # 步骤2：用集合去重（集合元素唯一，自动过滤重复值）
    unique_targets = {item['target'] for item in data if 'target' in item and item['target']}

    # 步骤3：转回列表（可选排序，让结果顺序更稳定）
    result_list = sorted([f"{target}" for target in unique_targets])
    max_show = 20
    if len(result_list) > max_show:
        formatted_result = "\n".join([f"{idx+1}. {content}" for idx, content in enumerate(result_list[:max_show])])
        return f"“{entity_name}”的{relationship_type}共{len(result_list)}条，显示前{max_show}条：\n{formatted_result}"
    else:
        formatted_result = "\n".join([f"{idx+1}. {content}" for idx, content in enumerate(result_list)])
        return f"“{entity_name}”的{relationship_type}如下：\n{formatted_result}"

def format_tobacco_type_answer(data: list, entity_name: str) -> str:
    """烟叶类型的查询函数"""
    if not data:
        return f"回答：抱歉，没有找到“{entity_name}”相关的烟叶信息。请继续补充相关知识！"

    def normalize_text(text):
        # 1. 中文逗号→英文逗号 2. 中文句号→英文句号 3. 去除前后多余空格
        return text.replace('，', ',').replace('。', '.').strip()
    # 步骤2：用集合去重（集合元素唯一，自动过滤重复值）
    unique_targets = {item['target'] for item in data if 'target' in item and item['target']}

    # 步骤3：转回列表（可选排序，让结果顺序更稳定）
    result_list = sorted([f"{target}" for target in unique_targets])
    max_show = 20
    if len(result_list) > max_show:
        formatted_result = "\n".join([f"{idx+1}. {content}" for idx, content in enumerate(result_list[:max_show])])
        return f"“{entity_name}”相关的烟叶类型有{len(result_list)}条，显示前{max_show}条：\n{formatted_result}"
    else:
        formatted_result = "\n".join([f"{idx+1}. {content}" for idx, content in enumerate(result_list)])
        return f"“{entity_name}”相关的烟叶类型如下：\n{formatted_result}"

def format_smoking_method_answer(data: list, entity_name: str) -> str:
    """评吸方式的查询函数"""
    if not data:
        return f"回答：抱歉，没有找到“{entity_name}”的信息。请继续补充相关知识！"

    def normalize_text(text):
        # 1. 中文逗号→英文逗号 2. 中文句号→英文句号 3. 去除前后多余空格
        return text.replace('，', ',').replace('。', '.').strip()
    # 步骤2：用集合去重（集合元素唯一，自动过滤重复值）
    unique_targets = {item['target'] for item in data if 'target' in item and item['target']}

    # 步骤3：转回列表（可选排序，让结果顺序更稳定）
    result_list = sorted([f"{target}" for target in unique_targets])
    max_show = 20
    if len(result_list) > max_show:
        formatted_result = "\n".join([f"{idx+1}. {content}" for idx, content in enumerate(result_list[:max_show])])
        return f"“{entity_name}”的{len(result_list)}条，显示前{max_show}条：\n{formatted_result}"
    else:
        formatted_result = "\n".join([f"{idx+1}. {content}" for idx, content in enumerate(result_list)])
        return f"“{entity_name}”的如下：\n{formatted_result}"

def format_analysis_method_answer(data: list, entity_name: str) -> str:
    """致甜成分分析方法的查询函数"""
    if not data:
        return f"回答：抱歉，没有找到“{entity_name}”的实验方法信息。请继续补充相关知识！"

    def normalize_text(text):
        # 1. 中文逗号→英文逗号 2. 中文句号→英文句号 3. 去除前后多余空格
        return text.replace('，', ',').replace('。', '.').strip()
    # 步骤2：用集合去重（集合元素唯一，自动过滤重复值）
    unique_targets = {item['target'] for item in data if 'target' in item and item['target']}

    # 步骤3：转回列表（可选排序，让结果顺序更稳定）
    result_list = sorted([f"{target}" for target in unique_targets])
    max_show = 20
    if len(result_list) > max_show:
        formatted_result = "\n".join([f"{idx+1}. {content}" for idx, content in enumerate(result_list[:max_show])])
        return f"“{entity_name}”的分析方法共{len(result_list)}条，显示前{max_show}条：\n{formatted_result}"
    else:
        formatted_result = "\n".join([f"{idx+1}. {content}" for idx, content in enumerate(result_list)])
        return f"“{entity_name}”的分析方法如下：\n{formatted_result}"


def format_add_way_answer(data: list, entity_name: str, relationship_type: str) -> str:
    """致甜成分添加方式查询的回答函数"""
    if not data:
        return f"抱歉，没有找到关于“{entity_name}”的{relationship_type}信息。请继续补充相关知识！"

    result_list = [item['target'] for item in data if 'target' in item and item['target']]
    # 可选：限制最多显示20条，超过时提示“共X条，显示前20条”
    max_show = 20
    if len(result_list) > max_show:
        formatted_result = "\n".join([f"{idx+1}. {content}" for idx, content in enumerate(result_list[:max_show])])
        return f"“{entity_name}”的{relationship_type}共{len(result_list)}条，显示前{max_show}条：\n{formatted_result}"
    else:
        formatted_result = "\n".join([f"{idx+1}. {content}" for idx, content in enumerate(result_list)])
        return f"“{entity_name}”的{relationship_type}如下：\n{formatted_result}"


def format_contain_ingredient_answer(data: list, entity_name: str, relationship_type: str) -> str:
    """哪些论文涉及某个致甜成分查询的回答函数（多结果分点，论文名称按“_前部分”去重）"""
    if not data:
        return f"回答：抱歉，没有找到关于“{entity_name}”的{relationship_type}信息。请继续补充相关知识！"

    # -------------------------- 核心预处理（分场景处理论文名称） --------------------------
    def process_target(target_text):
        """
        预处理目标文本：
        1. 先字符归一化（解决中英文符号/空格问题）
        2. 若为“论文/文献”场景，提取“_”前的核心标题（用于去重）
        3. 返回（核心标识，原始展示文本）：去重依据核心标识，展示用原始文本
        """
        # 步骤1：原有字符格式归一化（保留）
        normalized = target_text.replace('，', ',').replace('。', '.').strip()

        # 步骤2：判断是否为“论文/文献”相关场景（根据relationship_type匹配，避免影响其他场景）
        paper_related_types = ["相关论文", "文献", "提到的论文", "涉及的文献"]  # 可根据实际场景扩展
        if any(keyword in relationship_type for keyword in paper_related_types):
            # 论文场景：提取“_”前的核心标题（去重依据），保留原始归一化文本用于展示
            core_identifier = normalized.split('_')[0].strip()  # 核心标识：_前部分
            display_text = normalized  # 展示文本：完整归一化名称（含_后缀）
        else:
            # 非论文场景：核心标识=展示文本（保持原有去重逻辑）
            core_identifier = normalized
            display_text = normalized

        return core_identifier, display_text

    # -------------------------- 步骤1：处理所有目标，生成“核心标识-展示文本”映射 --------------------------
    target_mapping = {}  # 键：核心标识（用于去重），值：展示文本（用于最终输出）
    for item in data:
        if 'target' in item and item['target']:
            raw_target = str(item['target'])
            core_id, display_txt = process_target(raw_target)
            # 去重逻辑：同一核心标识只保留第一个展示文本（避免重复）
            if core_id not in target_mapping:
                target_mapping[core_id] = display_txt

    # -------------------------- 步骤2：从映射中提取去重后的展示列表 --------------------------
    # 转为列表并排序（保持结果稳定）
    result_list = sorted(target_mapping.values())

    # -------------------------- 步骤3：原有分点+数量限制逻辑（完全保留） --------------------------
    max_show = 20
    if len(result_list) > max_show:
        formatted_result = "\n".join([f"{idx + 1}. 《{content}》" for idx, content in enumerate(result_list[:max_show])])
        return f"回答：提到或者涉及“{entity_name}”的{relationship_type}共{len(result_list)}条，显示前{max_show}条：\n{formatted_result}"
    else:
        formatted_result = "\n".join([f"{idx + 1}. {content}" for idx, content in enumerate(result_list)])
        return f"回答：提到或者涉及“{entity_name}”的{relationship_type}如下：\n{formatted_result}"

def format_ingredients_answer(data: list, entity_name: str, relationship_type: str) -> str:
    """某篇论文研究致甜成分查询的回答函数（多结果用“、”连接）"""
    if not data:
        return f"回答：抱歉，没有找到关于“{entity_name}”的{relationship_type}信息。"
    # 步骤1：字符格式归一化（关键！解决中英文符号/空格导致的假重复）
    def normalize_text(text):
        # 1. 中文逗号→英文逗号 2. 中文句号→英文句号 3. 去除前后多余空格
        return text.replace('，', ',').replace('。', '.').strip()
    # 步骤2：用集合去重（集合元素唯一，自动过滤重复值）
    unique_targets = {item['target'] for item in data if 'target' in item and item['target']}

    # 步骤3：转回列表（可选排序，让结果顺序更稳定）
    result_list = sorted([f"{target}" for target in unique_targets])
    if result_list:
        result_str = "、".join(result_list)
        return f"回答：论文《{entity_name}》中{relationship_type}有：{result_str}。"
    else:
        return f"回答：抱歉，没有找到相关信息。请继续补充相关知识！"

def format_add_method_answer(data: list, entity_name: str, relationship_type: str) -> str:
    """致甜成分添加方法查询的回答函数（多结果用“、”连接）"""
    if not data:
        return f"回答：抱歉，没有找到关于“{entity_name}”的{relationship_type}信息。请继续补充相关知识！"
    # 步骤1：字符格式归一化（关键！解决中英文符号/空格导致的假重复）
    def normalize_text(text):
        # 1. 中文逗号→英文逗号 2. 中文句号→英文句号 3. 去除前后多余空格
        return text.replace('，', ',').replace('。', '.').strip()
    # 步骤2：用集合去重（集合元素唯一，自动过滤重复值）
    unique_targets = {item['target'] for item in data if 'target' in item and item['target']}

    # 步骤3：转回列表（可选排序，让结果顺序更稳定）
    result_list = sorted([f"{target}" for target in unique_targets])
    # 所有节点的核心属性均为「name」（与导入脚本一致）
    max_show = 20
    if len(result_list) > max_show:
        formatted_result = "\n".join([f"{idx+1}. {content}" for idx, content in enumerate(result_list[:max_show])])
        return f"回答：关于“{entity_name}”的{relationship_type}共{len(result_list)}条，显示前{max_show}条：\n{formatted_result}"
    else:
        formatted_result = "\n".join([f"{idx+1}. {content}" for idx, content in enumerate(result_list)])
        return f"回答：关于“{entity_name}”的{relationship_type}如下：\n{formatted_result}"


def format_characteristics_answer(data: list, entity_name: str) -> str:
    """
    致甜成分的优点/缺点查询的回答函数
    数据来自两个关系：致甜成分名称-[:优点]->致甜成分的优点、致甜成分名称-[:缺点]->致甜成分的缺点
    输出结构：优点分点+缺点分点（1、2、...编号）
    """
    if not data:
        return f"回答：抱歉，没有找到关于“{entity_name}”的特性信息。请继续补充相关知识！"

    # 提取优点和缺点列表（从查询结果的两个字段中获取）
    features = data[0]
    advantages = features.get('advantages', [])  # 致甜成分的优点节点name列表（已去重）
    disadvantages = features.get('disadvantages', [])  # 致甜成分的缺点节点name列表（已去重）

    response_parts = []  # 存储优点、缺点的分点内容

    # -------------------------- 处理优点：分点编号（1、2、3...） --------------------------
    if advantages:
        # 遍历优点列表，生成“1、xxx\n2、xxx”格式（\n表示换行）
        advantages_formatted = "\n".join([
            f"{idx+1}、{adv.strip()}"  # 序号从1开始，去除每个优点的多余空格
            for idx, adv in enumerate(advantages)
        ])
        # 拼接“优点：”引导语，加入response_parts
        response_parts.append(f"优点：\n{advantages_formatted}")

    # -------------------------- 处理缺点：分点编号（1、2、3...） --------------------------
    if disadvantages:
        # 同理，遍历缺点列表生成分点格式
        disadvantages_formatted = "\n".join([
            f"{idx+1}、{disadv.strip()}"
            for idx, disadv in enumerate(disadvantages)
        ])
        # 拼接“缺点：”引导语，加入response_parts
        response_parts.append(f"缺点：\n{disadvantages_formatted}")

    # -------------------------- 拼接最终回答 --------------------------
    if response_parts:
        # 用“\n\n”分隔优点和缺点，避免内容拥挤
        characteristics_content = "\n\n".join(response_parts)
        return f"回答：关于“{entity_name}”的特性：\n{characteristics_content}"
    else:
        return f"回答：抱歉，没有找到关于“{entity_name}”的特性信息。请继续补充相关知识！"


def format_add_amount_taste_answer(data: list, entity_name: str) -> str:
    """
    致甜成分添加量及口感查询的回答函数

    """
    if not data:
        return f"回答：抱歉，没有找到关于“{entity_name}”的添加量及口感信息。请继续补充相关知识！"

    # 目标节点属性为「name」，直接提取
    info = data[0]['target'] if 'target' in data[0] else '未提及'
    return f"回答：“{entity_name}”的添加量及口感信息为：{info}。"

def format_aroma_answer(data: list, entity_name: str) -> str:
    """
    致甜成分香气查询的回答函数

    """
    if not data:
        return f"回答：抱歉，没有找到关于“{entity_name}”的香气信息。请继续补充相关知识！"

    # 目标节点属性为「name」，直接提取
    info = data[0]['target'] if 'target' in data[0] else '未提及'
    return f"回答：“{entity_name}”的香气特点为：{info}。"


def format_single_relation_answer(data: list, entity_name: str, relationship_type: str) -> str:
    """致甜成分添加方法、相对甜度等查询的回答函数"""
    if not data:
        return f"回答：抱歉，没有找到关于“{entity_name}”的{relationship_type}信息。请继续补充相关知识！"
    # 步骤1：字符格式归一化（关键！解决中英文符号/空格导致的假重复）
    def normalize_text(text):
        # 1. 中文逗号→英文逗号 2. 中文句号→英文句号 3. 去除前后多余空格
        return text.replace('，', ',').replace('。', '.').strip()
    # 步骤2：用集合去重（集合元素唯一，自动过滤重复值）
    unique_targets = {item['target'] for item in data if 'target' in item and item['target']}

    # 步骤3：转回列表（可选排序，让结果顺序更稳定）
    result_list = sorted([f"{target}" for target in unique_targets])

    if result_list:
        result_str = "、".join(result_list)
        return f"回答：“{entity_name}”的{relationship_type}为：{result_str}。"
    else:
        return f"回答：抱歉，没有找到相关信息。请继续补充相关知识！"


def format_transfer_rate_answer(data: list, entity_name: str) -> str:
    """
    烟气/烟丝中含量及迁移率查询的回答函数
    """
    if not data:
        return f"回答：抱歉，没有找到关于“{entity_name}”在烟叶/烟丝中的含量及迁移率信息。请继续补充相关知识！"

    info = data[0]['target'] if 'target' in data[0] else '未提及'
    return f"回答：“{entity_name}”在烟气/烟丝中的含量及迁移率信息为：{info}。"


# ---------------------------------------------主问答函数------------------------------------------------------
def answer_question(question: str) -> str:
    """
    处理用户的自然语言问题，并返回答案。
    核心对齐点：
    1. 节点标签：与CSV列名一致（如“致甜成分名称”“论文名称”）
    2. 关系类型：与导入脚本的关系定义一致（如“研究论文”“应用于”）
    3. 节点属性：所有节点统一使用「name」属性（导入脚本核心属性）
    """
    if not graph:
        return "回答：抱歉，无法连接到图数据库。"
    # 规则15：致甜成分名称 → 香气（匹配「香气」关系）
    match_aroma = re.search(
        r'(?:《|“|)(.+?)(?:》|”|)的(?:香气|香味特征|香气特点|香气属性|香味描述)\??', question)
    if match_aroma:
        ingredient_name = match_aroma.group(1).strip()
        query = f"""
        MATCH (:致甜成分名称 {{name: '{ingredient_name}'}})-[:香气]->(m:致甜成分的香气)
        RETURN m.name AS target
        """
        result_data = execute_query_and_get_data(query)
        return format_aroma_answer(result_data, ingredient_name)

    # 规则1: 甜味剂类型 → 研究论文 → 论文名称（匹配导入脚本示例1）
    match = re.search(r'(?:《|“|)(.+?)(?:》|”|)(?:有什么|哪些)?(?:文献|论文)？', question)
    if match:
        sweetener_type = match.group(1).strip()
        query = f"""
        MATCH (:甜味剂类型 {{name: '{sweetener_type}'}})-[:研究论文]->(m:论文名称)
        RETURN m.name AS target LIMIT 10
        """
        result_data = execute_query_and_get_data(query)
        return format_general_answer(result_data, sweetener_type, "相关的文献")

    # 规则2: 论文名称 → 致甜物质 → 致甜成分名称（匹配导入脚本示例2）
    match = re.search(r'(?:《|“)(.+?)(?:》|”)(中|)(提到了|涉及到)(哪些|什么)(致甜成分|致甜物质)？', question)
    if match:
        paper_name = match.group(1).strip()

        query = f"""
        MATCH (:论文名称 {{name: '{paper_name}'}})-[:致甜物质]->(e:致甜成分名称)
        RETURN e.name AS target
        """
        result_data = execute_query_and_get_data(query)
        return format_ingredients_answer(result_data, paper_name, "提到的致甜成分")

    # 规则3：致甜成分名称 → 优点/缺点（匹配导入脚本的「优点」「缺点」关系）
    match = re.search(r'(?:《|“|)(.+?)(?:》|”|)有什么(特点|优点|缺点|特性)？', question)
    if match:
        ingredient_name = match.group(1).strip()

        query = f"""
        MATCH (i:致甜成分名称 {{name: '{ingredient_name}'}})
        OPTIONAL MATCH (i)-[:优点]->(adv:致甜成分的优点)
        OPTIONAL MATCH (i)-[:缺点]->(dis:致甜成分的缺点)
        RETURN COLLECT(DISTINCT adv.name) AS advantages, COLLECT(DISTINCT dis.name) AS disadvantages
        """
        result_data = execute_query_and_get_data(query)
        return format_characteristics_answer(result_data, ingredient_name)

    # 规则4: 致甜成分名称 → 应用于 → 致甜成分的应用（匹配导入脚本示例3）
    match = re.search(r'(?:《|“|)(.+?)(?:》|”|)(用在哪里|应用是什么|应用场景是哪些)？', question)
    if match:
        ingredient_name = match.group(1).strip()

        query = f"""
        MATCH (:致甜成分名称 {{name: '{ingredient_name}'}})-[:应用于]->(a:致甜成分的应用)
        RETURN a.name AS target
        """
        result_data = execute_query_and_get_data(query)
        return format_add_method_answer(result_data, ingredient_name, "应用场景")

    # 规则5：致甜成分名称 → 添加量及口感（匹配导入脚本的「添加量及口感」关系）
    match = re.search(r'(?:《|“|)(.+?)(?:》|”|)的添加量及(感受|口感)是怎样的？', question)
    if match:
        ingredient_name = match.group(1).strip()

        query = f"""
        MATCH (:致甜成分名称 {{name: '{ingredient_name}'}})-[:添加量及口感]->(m:致甜成分添加量及口感)
        RETURN m.name AS target
        """
        result_data = execute_query_and_get_data(query)
        return format_add_amount_taste_answer(result_data, ingredient_name)

    # 规则6A: 致甜成分名称 → 实验方法（导入脚本无「添加方式」，实际为「实验方法」关系）
    match_method = re.search(r'(?:《|“|)(.+?)(?:》|”|)的(实验|制备)(?:方式|方法|流程)是(什么|怎样的)？', question)
    if match_method:
        ingredient_name = match_method.group(1).strip()

        query = f"""
        MATCH (:致甜成分名称 {{name: '{ingredient_name}'}})-[:实验方法]->(m:致甜成分实验方法)
        RETURN m.name AS target
        """
        result_data = execute_query_and_get_data(query)
        return format_experimental_method_answer(result_data, ingredient_name, "实验方法")

    # 规则6B: 致甜成分名称 → 实验方法（问法二：怎么添加）
    match_how_to_add = re.search(r'(?:《|“|)(.+?)(?:》|”|)(怎么|如何)添加？', question)
    if match_how_to_add:
        ingredient_name = match_how_to_add.group(1).strip()
        query = f"""
        MATCH (:致甜成分名称 {{name: '{ingredient_name}'}})-[:添加方式]->(m:致甜成分的添加方法)
        RETURN m.name AS target
        """
        result_data = execute_query_and_get_data(query)
        return format_add_way_answer(result_data, ingredient_name, "添加方法")

    # 规则7: 致甜成分名称 → 相对甜度（匹配导入脚本的「相对甜度」关系）
    match_sweetness = re.search(r'(?:《|“|)(.+?)(?:》|”|)的(相对甜度|甜度)是多少？', question)
    if match_sweetness:
        ingredient_name = match_sweetness.group(1).strip()

        query = f"""
        MATCH (:致甜成分名称 {{name: '{ingredient_name}'}})-[:相对甜度]->(m:致甜成分相对甜度)
        RETURN m.name AS target
        """
        result_data = execute_query_and_get_data(query)
        return format_single_relation_answer(result_data, ingredient_name, "相对甜度")

    # 规则8：致甜成分名称 → 持久性 → 甜味持久性（匹配导入脚本的「持久性」关系）
    match_duration = re.search(r'(?:《|“|)(.+?)(?:》|”|)的甜味(?:持久性|持续性)(如何|怎么样)？', question)
    if match_duration:
        ingredient_name = match_duration.group(1).strip()

        query = f"""
        MATCH (:致甜成分名称 {{name: '{ingredient_name}'}})-[:持久性]->(m:甜味持久性)
        RETURN m.name AS target
        """
        result_data = execute_query_and_get_data(query)
        return format_single_relation_answer(result_data, ingredient_name, "甜味持久性")

    # 规则9：致甜成分名称 → 含量及迁移率（匹配导入脚本的「含量及迁移率」关系）
    match_transfer = re.search(
        r'(?:《|“|)(.+?)(?:》|”|)在(?:烟叶|烟丝|烟草)中的(?:含量|迁移率|含量及迁移率|含量和迁移率)\??', question)
    if match_transfer:
        ingredient_name = match_transfer.group(1).strip()

        query = f"""
        MATCH (:致甜成分名称 {{name: '{ingredient_name}'}})-[:含量及迁移率]->(m:致甜成分烟气烟丝中的含量及迁移率)
        RETURN m.name AS target
        """
        result_data = execute_query_and_get_data(query)
        return format_transfer_rate_answer(result_data, ingredient_name)

    # 规则10：致甜成分名称 ← 致甜物质 ← 论文名称（反向匹配，匹配导入脚本示例2）
    match_doc = re.search(r'(?:《|“|)(.+?)(?:》|”|)这个成分在哪些文献中(?:被)?提到了？', question)
    if match_doc:
        ingredient_name = match_doc.group(1).strip()

        query = f"""
        MATCH (:致甜成分名称 {{name: '{ingredient_name}'}})<-[:致甜物质]-(doc:论文名称)
        RETURN doc.name AS target
        """
        result_data = execute_query_and_get_data(query)
        return format_contain_ingredient_answer(result_data, ingredient_name, "相关文献")

    # 规则11：致甜成分名称 → 分析方法（匹配「分析方法」关系）
    match_analysis = re.search(
        r'(?:《|“|)(.+?)(?:》|”|)的(?:分析方法|检测方法|测定方法|分析方式)\??', question)
    if match_analysis:
        ingredient_name = match_analysis.group(1).strip()
        query = f"""
        MATCH (:致甜成分名称 {{name: '{ingredient_name}'}})-[:分析方法]->(m:致甜成分分析方法)
        RETURN m.name AS target
        """
        result_data = execute_query_and_get_data(query)
        return format_analysis_method_answer(result_data, ingredient_name)

    # 规则12：致甜成分名称 → 烟叶类型（匹配「烟叶类型」关系）
    match_tobacco_type = re.search(
        r'(?:《|“|)(.+?)(?:》|”|)相关的(?:烟叶类型|烟草类型|烟叶种类|烟草种类)\??', question)
    if match_tobacco_type:
        ingredient_name = match_tobacco_type.group(1).strip()
        query = f"""
        MATCH (:致甜成分名称 {{name: '{ingredient_name}'}})-[:烟叶类别]->(m:烟叶类型)
        RETURN m.name AS target
        """
        result_data = execute_query_and_get_data(query)
        return format_tobacco_type_answer(result_data, ingredient_name)

    # 规则13：致甜成分名称 → 评吸方法（匹配「评吸方法」关系）
    match_smoking = re.search(
        r'(?:《|“|)(.+?)(?:》|”|)的(?:评吸方法|抽吸评价方法|感官评吸方法|评吸方式)\??', question)
    if match_smoking:
        ingredient_name = match_smoking.group(1).strip()
        query = f"""
        MATCH (:致甜成分名称 {{name: '{ingredient_name}'}})-[:评吸方式]->(m:评吸方法)
        RETURN m.name AS target
        """
        result_data = execute_query_and_get_data(query)
        return format_smoking_method_answer(result_data, ingredient_name)

    # 如果所有规则都不匹配
    return "抱歉，我暂时无法理解你的问题。请尝试换一种说法，例如“天然植物提取物有什么文献？”"



# 步骤E: 测试问答系统（与导入脚本数据结构对齐）
if __name__ == "__main__":
    print(">>> 测试问题1：天然植物提取物有什么文献？")
    print(answer_question("天然植物提取物有什么文献？"))
    print("\n>>> 测试问题2：《罗望子提取物挥发性成分分析及其应用_覃荣》中提到了哪些致甜成分？")
    print(answer_question("《罗望子提取物挥发性成分分析及其应用_覃荣》中提到了哪些致甜成分？"))
    print("\n>>> 测试问题3：绿原酸有什么特点？")
    print(answer_question("绿原酸有什么特点？"))
    print("\n>>> 测试问题4：糠醛用在哪里？")
    print(answer_question("糠醛用在哪里？"))
    print("\n>>> 测试问题5：5-羟甲基糠醛的添加量及感受是怎样的？")
    print(answer_question("5-羟甲基糠醛的添加量及感受是怎样的？"))
    print("\n>>> 测试问题6：麦芽酚怎么添加？")
    print(answer_question("麦芽酚怎么添加？"))
    print("\n>>> 测试问题7：山梨醇的相对甜度是多少？")
    print(answer_question("山梨醇的相对甜度是多少？"))
    print("\n>>> 测试问题8：DDMP-5-肉桂酸酯的甜味持续性如何？")
    print(answer_question("DDMP-5-肉桂酸酯的甜味持续性如何？"))
    print("\n>>> 测试问题9：麦芽酚在烟叶中的含量及迁移率？")
    print(answer_question("麦芽酚在烟叶中的含量及迁移率？"))
    print("\n>>> 测试问题10：糠醛这个成分在哪些文献中提到了？")
    print(answer_question("糠醛这个成分在哪些文献中提到了？"))
    print("\n>>> 测试问题11：麦芽酚的实验方法是什么？")
    print(answer_question("麦芽酚的实验方法是什么？"))
    print("\n>>> 测试问题12：2,3-二氢-3,5-二羟基-6-甲基-4H-吡喃-4-酮（DDMP）的分析方法是什么？")
    print(answer_question("2,3-二氢-3,5-二羟基-6-甲基-4H-吡喃-4-酮（DDMP）的分析方法是什么？"))
    print("\n>>> 测试问题13：香兰素相关的烟叶类型？")
    print(answer_question("香兰素相关的烟叶类型？"))
    print("\n>>> 测试问题14：麦芽酚的评吸方式？")
    print(answer_question("麦芽酚的评吸方式？"))
    print("\n>>> 测试问题15：“5-羟甲基糠醛的香气特点？")
    print(answer_question("5-羟甲基糠醛的香气特点？"))